#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <aclconio.h>
#include <define.h>
#include <transact.h>
#include <tran.h>
#include <gds.h>
#include <sizes.h>
#include "ConfProto.h"
#include "tblutil.h"
#include <\SOFTPAY\Ver30\source\include\sizes.h>
#include <\SOFTPAY\Ver30\HostSrc\citisrc\citiids.h>
#include <\SOFTPAY\Ver30\HostSrc\cpacsrc\cpacids.h>
#include <confio.h>

#include <\SOFTPAY\Ver30\source\include\CTL.h>



static void *storeFromStruct;

static int recordNum;
void registerCTL(void *ptr)
{
	 storeFromStruct = ptr;
}

void *dealWithAddressBoundary(void*address)
{
char* tmp = (char*)address;
	int size = ((long)address) % 4;
	if(size != 0)
		tmp += (4-size);
	return tmp;
}

int	inLoadCTLRecFromStruct (int inRecNumber, void *vdStruct)
{
	int inRet;
	char* tmp = (char*)vdStruct;

	registerCTL(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inLoadConfRec(CTL_FILENAME, SIZE_CTL_REC, inRecNumber, vdStruct);

	recordNum = inRecNumber;
	return inRet;
}

void vdRestoreCTLRecFromStruct(void *vdStruct)
{
	registerCTL(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	memcpy((char *) pvdGetCTLRec(), vdStruct, SIZE_CTL_REC);

}

void vdCopyCTLRecFromStruct(void *vdStruct)
{
	registerCTL(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
		memcpy(vdStruct, (char *) pvdGetCTLRec(), SIZE_CTL_REC);

}

int	inSaveCTLRecFromStruct (int inRecNumber,  void *vdStruct)
{
	int inRet;

	registerCTL(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inSaveConfRec(CTL_FILENAME, SIZE_CTL_REC, inRecNumber, (char *) vdStruct);

	return inRet;
}

int	inUpdateCTLRecFromStruct (void *vdStruct)
{
	int inRet;

	registerCTL(vdStruct);
	vdStruct = dealWithAddressBoundary(vdStruct);
	inRet = inSaveConfRec(CTL_FILENAME, SIZE_CTL_REC, recordNum, (char *) vdStruct);

	return inRet;
}

short shGetImamCTLIndexFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return shGetImamCTLIndex();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->shImamCTLIndex;
}

void vdSetImamCTLIndexFromStruct(short shImamCTLIndex, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLIndex(shImamCTLIndex);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((CTL_REC*)vdStruct)->shImamCTLIndex = shImamCTLIndex;
}

short shGetImamCTLTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return shGetImamCTLType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->shImamCTLType;
}

void vdSetImamCTLTypeFromStruct(short shImamCTLType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLType(shImamCTLType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((CTL_REC*)vdStruct)->shImamCTLType = shImamCTLType;
}

char* szGetImamCTLPosEntryModeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLPosEntryMode();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLPosEntryMode;
}

void vdSetImamCTLPosEntryModeFromStruct(const char* szImamCTLPosEntryMode, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLPosEntryMode(szImamCTLPosEntryMode);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLPosEntryMode, szImamCTLPosEntryMode, sizeof(((CTL_REC*)NULL)->szImamCTLPosEntryMode)-1);
}

short shGetImamCTLComPortFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return shGetImamCTLComPort();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->shImamCTLComPort;
}

void vdSetImamCTLComPortFromStruct(short shImamCTLComPort, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLComPort(shImamCTLComPort);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((CTL_REC*)vdStruct)->shImamCTLComPort = shImamCTLComPort;
}

char* szGetImamCTLBaudRateFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLBaudRate();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLBaudRate;
}

void vdSetImamCTLBaudRateFromStruct(const char* szImamCTLBaudRate, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLBaudRate(szImamCTLBaudRate);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLBaudRate, szImamCTLBaudRate, sizeof(((CTL_REC*)NULL)->szImamCTLBaudRate)-1);
}

char* szGetImamCTLBaseUnitIndexFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLBaseUnitIndex();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLBaseUnitIndex;
}

void vdSetImamCTLBaseUnitIndexFromStruct(const char* szImamCTLBaseUnitIndex, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLBaseUnitIndex(szImamCTLBaseUnitIndex);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLBaseUnitIndex, szImamCTLBaseUnitIndex, sizeof(((CTL_REC*)NULL)->szImamCTLBaseUnitIndex)-1);
}

char* szGetImamCTLReaderUnitIndexFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLReaderUnitIndex();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLReaderUnitIndex;
}

void vdSetImamCTLReaderUnitIndexFromStruct(const char* szImamCTLReaderUnitIndex, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLReaderUnitIndex(szImamCTLReaderUnitIndex);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLReaderUnitIndex, szImamCTLReaderUnitIndex, sizeof(((CTL_REC*)NULL)->szImamCTLReaderUnitIndex)-1);
}

char* szGetImamCTLImekMdkFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLImekMdk();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLImekMdk;
}

void vdSetImamCTLImekMdkFromStruct(const char* szImamCTLImekMdk, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLImekMdk(szImamCTLImekMdk);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLImekMdk, szImamCTLImekMdk, sizeof(((CTL_REC*)NULL)->szImamCTLImekMdk)-1);
}

char* szGetImamCTLImekFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLImek();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLImek;
}

void vdSetImamCTLImekFromStruct(const char* szImamCTLImek, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLImek(szImamCTLImek);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLImek, szImamCTLImek, sizeof(((CTL_REC*)NULL)->szImamCTLImek)-1);
}

char* szGetImamCTLMekFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLMek();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLMek;
}

void vdSetImamCTLMekFromStruct(const char* szImamCTLMek, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLMek(szImamCTLMek);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLMek, szImamCTLMek, sizeof(((CTL_REC*)NULL)->szImamCTLMek)-1);
}

char* szGetImamCTLIaekMdkFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLIaekMdk();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLIaekMdk;
}

void vdSetImamCTLIaekMdkFromStruct(const char* szImamCTLIaekMdk, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLIaekMdk(szImamCTLIaekMdk);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLIaekMdk, szImamCTLIaekMdk, sizeof(((CTL_REC*)NULL)->szImamCTLIaekMdk)-1);
}

char* szGetImamCTLIaekFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLIaek();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLIaek;
}

void vdSetImamCTLIaekFromStruct(const char* szImamCTLIaek, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLIaek(szImamCTLIaek);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLIaek, szImamCTLIaek, sizeof(((CTL_REC*)NULL)->szImamCTLIaek)-1);
}

char* szGetImamCTLAekFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLAek();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLAek;
}

void vdSetImamCTLAekFromStruct(const char* szImamCTLAek, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLAek(szImamCTLAek);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLAek, szImamCTLAek, sizeof(((CTL_REC*)NULL)->szImamCTLAek)-1);
}

char* szGetImamCTLIckSessionFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLIckSession();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLIckSession;
}

void vdSetImamCTLIckSessionFromStruct(const char* szImamCTLIckSession, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLIckSession(szImamCTLIckSession);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLIckSession, szImamCTLIckSession, sizeof(((CTL_REC*)NULL)->szImamCTLIckSession)-1);
}

char* szGetImamCTLMSessionFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLMSession();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLMSession;
}

void vdSetImamCTLMSessionFromStruct(const char* szImamCTLMSession, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLMSession(szImamCTLMSession);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLMSession, szImamCTLMSession, sizeof(((CTL_REC*)NULL)->szImamCTLMSession)-1);
}

char* szGetImamCTLASessionFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLASession();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLASession;
}

void vdSetImamCTLASessionFromStruct(const char* szImamCTLASession, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLASession(szImamCTLASession);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLASession, szImamCTLASession, sizeof(((CTL_REC*)NULL)->szImamCTLASession)-1);
}

short shGetImamCTLMagStripeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return shGetImamCTLMagStripe();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->shImamCTLMagStripe;
}

void vdSetImamCTLMagStripeFromStruct(short shImamCTLMagStripe, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLMagStripe(shImamCTLMagStripe);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	((CTL_REC*)vdStruct)->shImamCTLMagStripe = shImamCTLMagStripe;
}

char* szGetImamCTLPaymentSchemeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLPaymentScheme();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLPaymentScheme;
}

void vdSetImamCTLPaymentSchemeFromStruct(const char* szImamCTLPaymentScheme, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLPaymentScheme(szImamCTLPaymentScheme);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLPaymentScheme, szImamCTLPaymentScheme, sizeof(((CTL_REC*)NULL)->szImamCTLPaymentScheme)-1);
}

char* szGetImamCTLReaderCVMFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLReaderCVM();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLReaderCVM;
}

void vdSetImamCTLReaderCVMFromStruct(const char* szImamCTLReaderCVM, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLReaderCVM(szImamCTLReaderCVM);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLReaderCVM, szImamCTLReaderCVM, sizeof(((CTL_REC*)NULL)->szImamCTLReaderCVM)-1);
}

char* szGetImamCTLDF04_CVMReqFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF04_CVMReq();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF04_CVMReq;
}

void vdSetImamCTLDF04_CVMReqFromStruct(const char* szImamCTLDF04_CVMReq, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF04_CVMReq(szImamCTLDF04_CVMReq);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF04_CVMReq, szImamCTLDF04_CVMReq, sizeof(((CTL_REC*)NULL)->szImamCTLDF04_CVMReq)-1);
}

char* szGetImamCTL9F66_CVM_TTQFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTL9F66_CVM_TTQ();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTL9F66_CVM_TTQ;
}

void vdSetImamCTL9F66_CVM_TTQFromStruct(const char* szImamCTL9F66_CVM_TTQ, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTL9F66_CVM_TTQ(szImamCTL9F66_CVM_TTQ);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTL9F66_CVM_TTQ, szImamCTL9F66_CVM_TTQ, sizeof(((CTL_REC*)NULL)->szImamCTL9F66_CVM_TTQ)-1);
}

char* szGetImamCTL9F35_TermTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTL9F35_TermType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTL9F35_TermType;
}

void vdSetImamCTL9F35_TermTypeFromStruct(const char* szImamCTL9F35_TermType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTL9F35_TermType(szImamCTL9F35_TermType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTL9F35_TermType, szImamCTL9F35_TermType, sizeof(((CTL_REC*)NULL)->szImamCTL9F35_TermType)-1);
}

char* szGetImamCTL9F1A_TCountryFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTL9F1A_TCountry();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTL9F1A_TCountry;
}

void vdSetImamCTL9F1A_TCountryFromStruct(const char* szImamCTL9F1A_TCountry, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTL9F1A_TCountry(szImamCTL9F1A_TCountry);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTL9F1A_TCountry, szImamCTL9F1A_TCountry, sizeof(((CTL_REC*)NULL)->szImamCTL9F1A_TCountry)-1);
}

char* szGetImamCTL5F2A_TCurrencyFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTL5F2A_TCurrency();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTL5F2A_TCurrency;
}

void vdSetImamCTL5F2A_TCurrencyFromStruct(const char* szImamCTL5F2A_TCurrency, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTL5F2A_TCurrency(szImamCTL5F2A_TCurrency);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTL5F2A_TCurrency, szImamCTL5F2A_TCurrency, sizeof(((CTL_REC*)NULL)->szImamCTL5F2A_TCurrency)-1);
}

char* szGetImamCTL9C_TrxTypeFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTL9C_TrxType();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTL9C_TrxType;
}

void vdSetImamCTL9C_TrxTypeFromStruct(const char* szImamCTL9C_TrxType, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTL9C_TrxType(szImamCTL9C_TrxType);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTL9C_TrxType, szImamCTL9C_TrxType, sizeof(((CTL_REC*)NULL)->szImamCTL9C_TrxType)-1);
}

char* szGetImamCTLDF03_fDDAFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF03_fDDA();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF03_fDDA;
}

void vdSetImamCTLDF03_fDDAFromStruct(const char* szImamCTLDF03_fDDA, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF03_fDDA(szImamCTLDF03_fDDA);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF03_fDDA, szImamCTLDF03_fDDA, sizeof(((CTL_REC*)NULL)->szImamCTLDF03_fDDA)-1);
}

char* szGetImamCTLDF05_OffFundFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF05_OffFund();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF05_OffFund;
}

void vdSetImamCTLDF05_OffFundFromStruct(const char* szImamCTLDF05_OffFund, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF05_OffFund(szImamCTLDF05_OffFund);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF05_OffFund, szImamCTLDF05_OffFund, sizeof(((CTL_REC*)NULL)->szImamCTLDF05_OffFund)-1);
}

char* szGetImamCTLDF00_TrxLimitFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF00_TrxLimit();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF00_TrxLimit;
}

void vdSetImamCTLDF00_TrxLimitFromStruct(const char* szImamCTLDF00_TrxLimit, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF00_TrxLimit(szImamCTLDF00_TrxLimit);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF00_TrxLimit, szImamCTLDF00_TrxLimit, sizeof(((CTL_REC*)NULL)->szImamCTLDF00_TrxLimit)-1);
}

char* szGetImamCTLDF01_CvmLimitFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF01_CvmLimit();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF01_CvmLimit;
}

void vdSetImamCTLDF01_CvmLimitFromStruct(const char* szImamCTLDF01_CvmLimit, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF01_CvmLimit(szImamCTLDF01_CvmLimit);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF01_CvmLimit, szImamCTLDF01_CvmLimit, sizeof(((CTL_REC*)NULL)->szImamCTLDF01_CvmLimit)-1);
}

char* szGetImamCTLDF02_FloorLimitFromStruct(void*vdStruct)
{
	if(vdStruct != storeFromStruct)
		return szGetImamCTLDF02_FloorLimit();
	vdStruct = dealWithAddressBoundary(vdStruct);
	return ((CTL_REC*)vdStruct)->szImamCTLDF02_FloorLimit;
}

void vdSetImamCTLDF02_FloorLimitFromStruct(const char* szImamCTLDF02_FloorLimit, void*vdStruct)
{
	if(vdStruct != storeFromStruct)
	{
		vdSetImamCTLDF02_FloorLimit(szImamCTLDF02_FloorLimit);
		return;
	}
	vdStruct = dealWithAddressBoundary(vdStruct);
	strNumCopy(((CTL_REC*)vdStruct)->szImamCTLDF02_FloorLimit, szImamCTLDF02_FloorLimit, sizeof(((CTL_REC*)NULL)->szImamCTLDF02_FloorLimit)-1);
}

